package chapter10.innerclass;

//匿名内部类
public class AnonymousInnerClass {
    public static void main(String[] args) {
        new Outer04().method();
    }
}

class Outer04 {
    private int n1 = 100;

    public void method() {
        //基于接口的匿名内部类
// 需求，想使用A接口，并创建对象，并且只使用一次，后面不在使用
//       可以使用匿名内部类
//        tiger的编译类型A
//        运行类型由底层JDK自动生成，名字为外部类名称$数
//       相当于
//       class Outer04$1 implements A{
//       @Override
//            public void cry() {
//                System.out.println("老虎叫...");
//            }
//          }
        A tiger = new A() {
            @Override
            public void cry() {
                System.out.println("老虎叫...");
            }
        };

        System.out.println(tiger.getClass());
        tiger.cry();
//        基于类演示的匿名内部类
//1.father的编译类型是Father
//2.father的运行类型是Outer04$2
//      相当于
//        class Outer04$2 extends Father{
//        }
//注：jack 会传递给Father类的构造器
//   匿名内部类也没办法有自己的构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("重写test方法");
                ;
            }
        };

//        输出father的运行类型
        father.test();
        System.out.println(father.getClass());
        System.out.println(father.getName());

//        基于抽象类的匿名内部类
        Animal rabbit = new Animal() {
            @Override
            void eat() {
                System.out.println("兔子吃草");
            }
        };
        rabbit.eat();
        System.out.println(rabbit.getClass());
    }
}

interface A {
    void cry();
}

class Father {
    private String name;

    public String getName() {
        return name;
    }

    public Father(String name) {
        this.name = name;
    }

    public void test() {
    }

    ;
}

abstract class Animal {
    abstract void eat();
}